home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / newton / newton.h < prev    next >
C/C++ Source or Header  |  1994-08-01  |  10KB  |  424 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  * Yossi Friedman, July 1988
  19.  */
  20.  
  21.  
  22. #ifdef MAIN
  23. #    define extern    /* nothing */
  24. #    define INIT(val)    = val
  25. #else /* MAIN */
  26. #    define INIT(val)    /* nothing */
  27. #endif /* MAIN */
  28.  
  29.  
  30.  
  31. /*
  32.  * set the right flags depending on the current graphics board
  33.  */
  34. #ifdef CLOVER1
  35. #   undef HAS_CZCLEAR
  36. #   undef HAS_BLENDING
  37. #   undef MP
  38. #endif /* CLOVER1 */
  39.  
  40. #ifdef ECLIPSE
  41. #   define HAS_CZCLEAR
  42. #   undef HAS_BLENDING
  43. #   undef MP
  44. #endif /* ECLIPSE */
  45.  
  46. #ifdef CLOVER1G
  47. #   define HAS_CZCLEAR
  48. #   define HAS_BLENDING
  49. #   undef MP
  50. #endif /* CLOVER1G */
  51.  
  52. #ifdef CLOVER2
  53. #   define HAS_CZCLEAR
  54. #   define HAS_BLENDING
  55. #   define MP
  56. #endif /* CLOVER2 */
  57.  
  58. /*
  59.  * Multiprocessor stuff
  60.  */
  61. #ifdef MP
  62.  
  63. extern int nproc;        /* number of CPUs */
  64. extern void slave(void *);
  65.  
  66. /* functions that slaves can perform: */
  67. #   define SLAVE_IDLE        0
  68. #   define SLAVE_DIE        1
  69. #   define DO_CLEAR        2
  70. #   define DO_ACCEL        3
  71. #   define DO_BOUNDS        4
  72. #   define DO_VEL_DAMP_POS    5
  73. #   define DO_ROTATE_MODEL    6
  74. #   define DO_ROTATE_PHYSICS    7
  75. #   define DRAW_FLAT_SURFS_1    8
  76. #   define DRAW_SMOOTH_SURFS_1    9
  77. #   define DRAW_SMOOTH_SURFS_2    10
  78. #   define DRAW_SMOOTH_SURFS_3    11
  79.  
  80. #   define SLAVE_FUNC(f)                \
  81.     do {                        \
  82.     int i;                        \
  83.                             \
  84.     for (i = 0; i < nproc; i++)            \
  85.         slave_func[i] = f;                \
  86.     } while (0)
  87.  
  88. #   define WAIT_FOR_SLAVE()                \
  89.     do {                        \
  90.     int waiting;                    \
  91.         int i;                        \
  92.                             \
  93.     for (waiting = 1; waiting;) {            \
  94.         waiting = 0;                \
  95.         for (i = 1; i < nproc; i++)            \
  96.             if (slave_func[i] != SLAVE_IDLE) {    \
  97.             waiting = 1;            \
  98.             break;                \
  99.         }                    \
  100.     }                        \
  101.     } while (0);
  102.  
  103. #   define MP_ARRAY        [MAX_NPROC]
  104. #   define CPU_PARAM        , cpu
  105. #   define MASTER_PARAM        , 0
  106. #   define CPU_PARAM_TYPE    int cpu
  107. #   define CPU            [cpu]
  108. #   define MASTER        [0]
  109. #   define TOTAL        [nproc-1]
  110.  
  111.  
  112. extern volatile int slave_func MP_ARRAY;
  113. extern int slave_pid MP_ARRAY;
  114.  
  115. /*
  116.  * debugging -- DO NOT start the slaves in the main program.  Instead,
  117.  * redefine WAIT_FOR_SLAVE as:
  118.  *
  119.  * #   define WAIT_FOR_SLAVE()                        \
  120.  *     do {                                \
  121.  *          int i;                            \
  122.  *          for (i = 1; i < nproc; i++)                    \
  123.  *              slave();                        \
  124.  *                                    \
  125.  *          slave_func[0] = 1;                        \
  126.  *          for (i = 1; i < nproc; i++)                    \
  127.  *              slave_func[0] &&= (slave_func[i] == SLAVE_IDLE);    \
  128.  *          if (slave_func[0] == 0)                    \
  129.  *              fprintf(stderr, "Slave(s) don't signal!\007\n");    \
  130.  *     } while (0)
  131.  *
  132.  * Also, remove the infinite loop from the slave routine.
  133.  */
  134.  
  135. #else /* MP */
  136.  
  137. #   define SLAVE_FUNC(f)    do /* nothing */ ; while (0)
  138. #   define MP_ARRAY        /* nothing */
  139. #   define SLAVE_IDLE         /* nothing */
  140. #   define WAIT_FOR_SLAVE()    do /* nothing */ ; while (0)
  141. #   define CPU_PARAM        /* nothing */
  142. #   define MASTER_PARAM        /* nothing */
  143. #   define CPU_PARAM_TYPE    /* nothing */
  144. #   define CPU            /* nothing */
  145. #   define MASTER        /* nothing */
  146. #   define TOTAL        /* nothing */
  147.  
  148. #endif /* MP */
  149.  
  150.  
  151.  
  152.  
  153. /*
  154.  * indices into a coordinate vector
  155.  */
  156. #define X 0
  157. #define Y 1
  158. #define Z 2
  159. #define W 3
  160.  
  161.  
  162. /*
  163.  * useful vector macros.  they are enclosed in this ridiculous null loop in
  164.  * order the make each a pseudo-statement.
  165.  *
  166.  * NOTE: the operands are nor parenthesized, so the macros should
  167.  * be invoked with care (priority of operators).
  168.  */
  169. #define vec_op(v, v1, op, v2)                        \
  170.     /* v = v1 op v2 */                            \
  171. do {                                    \
  172.     v[X] = v1[X] op v2[X];                        \
  173.     v[Y] = v1[Y] op v2[Y];                        \
  174.     v[Z] = v1[Z] op v2[Z];                        \
  175. } while (0)
  176.  
  177. #define cross(v, v1, v2)                        \
  178.     /* v = v1 x v2 */                            \
  179. do {                                    \
  180.     v[X] =   v1[Y]*v2[Z] - v1[Z]*v2[Y] ;                \
  181.     v[Y] = -(v1[X]*v2[Z] - v1[Z]*v2[X]);                \
  182.     v[Z] =   v1[X]*v2[Y] - v1[Y]*v2[X] ;                \
  183. } while (0)
  184.     
  185. #define dot(v1, v2)    (v1[X]*v2[X] + v1[Y]*v2[Y] + v1[Z]*v2[Z])
  186.  
  187. #define apply(b, a, M)                            \
  188.     /* b = a M */                            \
  189. do {                                    \
  190.     b[X] = a[X]*M[X][X] + a[Y]*M[Y][X] + a[Z]*M[Z][X] + M[W][X];    \
  191.     b[Y] = a[X]*M[X][Y] + a[Y]*M[Y][Y] + a[Z]*M[Z][Y] + M[W][Y];    \
  192.     b[Z] = a[X]*M[X][Z] + a[Y]*M[Y][Z] + a[Z]*M[Z][Z] + M[W][Z];    \
  193. } while (0)
  194.  
  195. #define normalize(v)                            \
  196.     /* v = v / |v| */                            \
  197. do {                                    \
  198.                                     \
  199.     float leni = 1. / sqrt(v[X]*v[X] + v[Y]*v[Y] + v[Z]*v[Z]);    \
  200.                                     \
  201.     v[X] *= leni;                            \
  202.     v[Y] *= leni;                            \
  203.     v[Z] *= leni;                            \
  204. } while (0)
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211. /*
  212.  * models catalog file
  213.  */
  214. extern char *model_catalog INIT(DEFAULT_MODEL_CATALOG);
  215.  
  216.  
  217.  
  218. #ifdef CONFIG_FILE
  219.  
  220. /*
  221.  * configuration file
  222.  */
  223. extern char *model_config INIT(DEFAULT_MODEL_CONFIG);
  224.  
  225. #endif /* CONFIG_FILE */
  226.  
  227.  
  228.  
  229.  
  230. /*
  231.  * the list of models
  232.  */
  233. extern char *model_names[MAX_MODELS], **end_model_names;
  234. extern int model_index;        /* index of current model in the name list */
  235.  
  236.  
  237.  
  238. /*
  239.  * the physical and geometric elements of the system
  240.  */
  241. typedef struct {
  242.     /* physics stuff */
  243.     float acc MP_ARRAY [3];
  244.     float vel[3];
  245.  
  246.     /* shared stuff between physics and draw */
  247.     float pos[3];
  248.  
  249.     /* draw stuff */
  250.     float norm MP_ARRAY [3];
  251. } Atom;
  252.  
  253. typedef struct {
  254.     float r0;
  255.     float k;
  256.     Atom *from;
  257.     Atom *to;
  258. } Spring;
  259.  
  260. typedef struct {
  261.     int n;
  262.     Atom **vert;
  263.     float *norm;    /* array of normals, size 4*n. 4 rather than 3 so it
  264.                would be fast to go from one normal to the next */
  265. } Surf;
  266.  
  267. extern Atom model_atoms[MAX_ATOMS], *end_model_atoms MP_ARRAY;
  268. extern Spring model_springs[MAX_SPRING], *end_model_springs MP_ARRAY;
  269. extern Surf model_surfs[MAX_SURF], *end_model_surfs MP_ARRAY;
  270.  
  271. extern float max_k;        /* current maximal model spring constant */
  272.  
  273.  
  274.  
  275. #define MODEL_MATERIAL_INDEX        1
  276. extern float model_material[MAX_LIGHTING_SIZE];
  277. extern int model_material_size;
  278.  
  279. extern float default_model_material[MAX_LIGHTING_SIZE]
  280.     INIT({ DEFAULT_MODEL_MATERIAL });
  281. extern int default_model_material_size
  282.     INIT(DEFAULT_MODEL_MATERIAL_SIZE);
  283.  
  284.  
  285.  
  286.  
  287. /*
  288.  * room walls structure
  289.  */
  290. extern struct wall {
  291.     /* draw stuff */
  292.     float real_v[4][3];        /* real vertices of the wall */
  293.     float real_norm[3];
  294.     float surf_v[4][3];        /* vertices of the wall surface */
  295.     float surf_e[4][3];        /* edges of the wall surface */
  296.     float surf_norm[5][3];    /* normals for dented walls */
  297.     float shadow[4][4];        /* shadow transformation matrix */
  298.  
  299.     int axis;            /* which axis does the wall lie on */
  300.     float sign;            /* on which side of that axis? +/- 1. */
  301.  
  302.     /* shared stuff between physics and draw -- penetrations into walls */
  303.     int penetrated;
  304.     float depth;
  305.     Atom *atom;
  306. } wall[6];
  307.  
  308. #define WALL_TOP    0
  309. #define WALL_BOTTOM    1
  310. #define WALL_RIGHT    2
  311. #define WALL_LEFT    3
  312. #define WALL_FRONT    4
  313. #define WALL_BACK    5
  314.  
  315.  
  316.  
  317. /*
  318.  * draw functions
  319.  */
  320. extern void draw_smooth_surfs(),
  321.      draw_flat_surfs(),
  322.      draw_springs(),
  323.      (*draw_model)();
  324.  
  325. extern void draw_lighted_wall(int),
  326.      draw_pinball_wall(int),
  327.      draw_plain_wall(int),
  328.      (*draw_wall)(int) INIT(DRAW_WALL_DEFAULT);
  329.  
  330.  
  331.  
  332. /*
  333.  * display state vars
  334.  */
  335.  
  336. /* display mode -- color map or RGB */
  337. #define     RGB        1
  338. #define        COLOR_MAP    0
  339. extern int mode INIT(DEFAULT_MODE);
  340.  
  341. /* should we draw shadows in lighted wall mode? */
  342. extern int shadows_too INIT(SHADOWS_TOO_DEFAULT);
  343.  
  344. /* should the springs be drawn as well as the surfaces? */
  345. extern int springs_too INIT(SPRINGS_TOO_DEFAULT);
  346.  
  347. /* should we draw a translucent model? */
  348. extern int alpha_blended INIT(ALPHA_BLENDED_DEFAULT);
  349.  
  350.  
  351.  
  352.  
  353.  
  354.  
  355.  
  356. /*
  357.  * sliders stuff -- common to physics and play:initialize_sliders.
  358.  * Physics sets the title, low, hi, dflt, and fun, as well as end_sliders.
  359.  * In initialize_sliders, the sid gets set.
  360.  */
  361. struct slider {
  362.     char *title;
  363.     float lo, hi, dflt;
  364.     void (*fun)(float);
  365.  
  366.     int sid;
  367. };
  368. extern struct slider sliders[100], *end_sliders;
  369.  
  370.  
  371.  
  372.  
  373.  
  374.  
  375. /*
  376.  * It transpires that because of the user interface, my transformation
  377.  * mechanism has to be somewhat different from the one supported by GL.
  378.  * I have to separate M (modeling transformations), V (viewing
  379.  * trans.) and P (projection trans.).  P has to be separated from the
  380.  * others because of the lighting model.  V and M have to be separated
  381.  * because of the rotation of the COORDINATE SYSTEM (rather than the
  382.  * objects themselves) -- this forces post-multiplication of M.
  383.  * Hence, I use `mmode(MVIEWING)' to keep P separated from the others,
  384.  * I keep a constant V at the top of the stack, and I keep M and M-inverse
  385.  * soft in my program.
  386.  *
  387.  * The routine `rotate_graphics' in file draw.c actually changes M
  388.  * and M-inverse.  The routines `rotate_model' (models.c) and
  389.  * `rotate_physics' (physics.c) use those matrices.  The reason why they
  390.  * need to use them is because rotations happen around a fixed axis in
  391.  * the viewing coordinate system, and the coordinates of the model and
  392.  * gravity vector are in the modeling coordinate system, which is attached
  393.  * to the room -- so in order to rotate around a viewing axis, the model
  394.  * and gravity coordinates have to be transformed into viewing coordinates,
  395.  * rotated, and returned to modeling coordinates.
  396.  */
  397.  
  398. #define IDENT_MATRIX        \
  399.     {                \
  400.         { 1., 0., 0., 0. },     \
  401.         { 0., 1., 0., 0. },    \
  402.         { 0., 0., 1., 0. },    \
  403.         { 0., 0., 0., 1. }    \
  404.     }
  405.  
  406. extern Matrix ident_matrix INIT(IDENT_MATRIX);
  407. extern Matrix M            INIT(IDENT_MATRIX);
  408. extern Matrix M_inv        INIT(IDENT_MATRIX);
  409. extern Matrix R;       /* general purpose */
  410.  
  411. #undef IDENT_MATRIX
  412.  
  413.  
  414.  
  415. #ifdef MAIN
  416. #    undef extern
  417. #endif /* MAIN */
  418.  
  419. #undef INIT
  420.  
  421. extern void set_default_k(float);
  422. extern void set_k(float);
  423.  
  424.